{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#default_exp vision.core\n",
    "#default_cls_lvl 3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#export\n",
    "from fastai.torch_basics import *\n",
    "from fastai.data.all import *\n",
    "\n",
    "from PIL import Image"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from fastai.data.external import *"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#hide\n",
    "from nbdev.showdoc import *"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#export\n",
    "_all_ = ['Image','ToTensor']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#It didn't use to be necessary to add ToTensor in all but we don't have the encodes methods defined here otherwise.\n",
    "#TODO: investigate"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Core vision\n",
    "> Basic image opening/processing functionality"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Helpers"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#export\n",
    "imagenet_stats = ([0.485, 0.456, 0.406], [0.229, 0.224, 0.225])\n",
    "cifar_stats    = ([0.491, 0.482, 0.447], [0.247, 0.243, 0.261])\n",
    "mnist_stats    = ([0.131], [0.308])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "im = Image.open(TEST_IMAGE).resize((30,20))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#export\n",
    "if not hasattr(Image,'_patched'):\n",
    "    _old_sz = Image.Image.size.fget\n",
    "    @patch_property\n",
    "    def size(x:Image.Image): return fastuple(_old_sz(x))\n",
    "    Image._patched = True"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#export\n",
    "@patch_property\n",
    "def n_px(x: Image.Image): return x.size[0] * x.size[1]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### `Image.n_px`\n",
    "\n",
    "> `Image.n_px` (property)\n",
    "\n",
    "Number of pixels in image"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "test_eq(im.n_px, 30*20)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#export\n",
    "@patch_property\n",
    "def shape(x: Image.Image): return x.size[1],x.size[0]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### `Image.shape`\n",
    "\n",
    "> `Image.shape` (property)\n",
    "\n",
    "Image (height,width) tuple (NB: opposite order of `Image.size()`, same order as numpy array and pytorch tensor)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "test_eq(im.shape, (20,30))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#export\n",
    "@patch_property\n",
    "def aspect(x: Image.Image): return x.size[0]/x.size[1]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### `Image.aspect`\n",
    "\n",
    "> `Image.aspect` (property)\n",
    "\n",
    "Aspect ratio of the image, i.e. `width/height`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "test_eq(im.aspect, 30/20)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#export\n",
    "@patch\n",
    "def reshape(x: Image.Image, h, w, resample=0):\n",
    "    \"`resize` `x` to `(w,h)`\"\n",
    "    return x.resize((w,h), resample=resample)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/markdown": [
       "<h4 id=\"Image.reshape\" class=\"doc_header\"><code>Image.reshape</code><a href=\"__main__.py#L2\" class=\"source_link\" style=\"float:right\">[source]</a></h4>\n",
       "\n",
       "> <code>Image.reshape</code>(**`x`**:`Image`, **`h`**, **`w`**, **`resample`**=*`0`*)\n",
       "\n",
       "`resize` `x` to `(w,h)`"
      ],
      "text/plain": [
       "<IPython.core.display.Markdown object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "show_doc(Image.Image.reshape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "test_eq(im.reshape(12,10).shape, (12,10))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#export\n",
    "@patch\n",
    "def to_bytes_format(im:Image.Image, format='png'):\n",
    "    \"Convert to bytes, default to PNG format\"\n",
    "    arr = io.BytesIO()\n",
    "    im.save(arr, format=format)\n",
    "    return arr.getvalue()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/markdown": [
       "<h4 id=\"Image.to_bytes_format\" class=\"doc_header\"><code>Image.to_bytes_format</code><a href=\"__main__.py#L2\" class=\"source_link\" style=\"float:right\">[source]</a></h4>\n",
       "\n",
       "> <code>Image.to_bytes_format</code>(**`im`**:`Image`, **`format`**=*`'png'`*)\n",
       "\n",
       "Convert to bytes, default to PNG format"
      ],
      "text/plain": [
       "<IPython.core.display.Markdown object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "show_doc(Image.Image.to_bytes_format)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#export\n",
    "@patch\n",
    "def to_thumb(self:Image.Image, h, w=None):\n",
    "    \"Same as `thumbnail`, but uses a copy\"\n",
    "    if w is None: w=h\n",
    "    im = self.copy()\n",
    "    im.thumbnail((w,h))\n",
    "    return im"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/markdown": [
       "<h4 id=\"Image.to_thumb\" class=\"doc_header\"><code>Image.to_thumb</code><a href=\"__main__.py#L2\" class=\"source_link\" style=\"float:right\">[source]</a></h4>\n",
       "\n",
       "> <code>Image.to_thumb</code>(**`h`**, **`w`**=*`None`*)\n",
       "\n",
       "Same as `thumbnail`, but uses a copy"
      ],
      "text/plain": [
       "<IPython.core.display.Markdown object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "show_doc(Image.Image.to_thumb)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#export\n",
    "@patch\n",
    "def resize_max(x: Image.Image, resample=0, max_px=None, max_h=None, max_w=None):\n",
    "    \"`resize` `x` to `max_px`, or `max_h`, or `max_w`\"\n",
    "    h,w = x.shape\n",
    "    if max_px and x.n_px>max_px: h,w = fastuple(h,w).mul(math.sqrt(max_px/x.n_px))\n",
    "    if max_h and h>max_h: h,w = (max_h    ,max_h*w/h)\n",
    "    if max_w and w>max_w: h,w = (max_w*h/w,max_w    )\n",
    "    return x.reshape(round(h), round(w), resample=resample)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "test_eq(im.resize_max(max_px=20*30).shape, (20,30))\n",
    "test_eq(im.resize_max(max_px=300).n_px, 294)\n",
    "test_eq(im.resize_max(max_px=500, max_h=10, max_w=20).shape, (10,15))\n",
    "test_eq(im.resize_max(max_h=14, max_w=15).shape, (10,15))\n",
    "test_eq(im.resize_max(max_px=300, max_h=10, max_w=25).shape, (10,15))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/markdown": [
       "<h4 id=\"Image.resize_max\" class=\"doc_header\"><code>Image.resize_max</code><a href=\"__main__.py#L2\" class=\"source_link\" style=\"float:right\">[source]</a></h4>\n",
       "\n",
       "> <code>Image.resize_max</code>(**`x`**:`Image`, **`resample`**=*`0`*, **`max_px`**=*`None`*, **`max_h`**=*`None`*, **`max_w`**=*`None`*)\n",
       "\n",
       "`resize` `x` to `max_px`, or `max_h`, or `max_w`"
      ],
      "text/plain": [
       "<IPython.core.display.Markdown object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "show_doc(Image.Image.resize_max)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Basic types"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This section regroups the basic types used in vision with the transform that create objects of those types."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#export\n",
    "def to_image(x):\n",
    "    \"Convert a tensor or array to a PIL int8 Image\"\n",
    "    if isinstance(x,Image.Image): return x\n",
    "    if isinstance(x,Tensor): x = to_np(x.permute((1,2,0)))\n",
    "    if x.dtype==np.float32: x = (x*255).astype(np.uint8)\n",
    "    return Image.fromarray(x, mode=['RGB','CMYK'][x.shape[0]==4])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#export\n",
    "def load_image(fn, mode=None):\n",
    "    \"Open and load a `PIL.Image` and convert to `mode`\"\n",
    "    im = Image.open(fn)\n",
    "    im.load()\n",
    "    im = im._new(im.im)\n",
    "    return im.convert(mode) if mode else im"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# export\n",
    "def image2tensor(img):\n",
    "    \"Transform image to byte tensor in `c*h*w` dim order.\"\n",
    "    res = tensor(img)\n",
    "    if res.dim()==2: res = res.unsqueeze(-1)\n",
    "    return res.permute(2,0,1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#export\n",
    "class PILBase(Image.Image, metaclass=BypassNewMeta):\n",
    "    _bypass_type=Image.Image\n",
    "    _show_args = {'cmap':'viridis'}\n",
    "    _open_args = {'mode': 'RGB'}\n",
    "    @classmethod\n",
    "    def create(cls, fn:(Path,str,Tensor,ndarray,bytes), **kwargs)->None:\n",
    "        \"Open an `Image` from path `fn`\"\n",
    "        if isinstance(fn,TensorImage): fn = fn.permute(1,2,0).type(torch.uint8)\n",
    "        if isinstance(fn, TensorMask): fn = fn.type(torch.uint8)\n",
    "        if isinstance(fn,Tensor): fn = fn.numpy()\n",
    "        if isinstance(fn,ndarray): return cls(Image.fromarray(fn))\n",
    "        if isinstance(fn,bytes): fn = io.BytesIO(fn)\n",
    "        return cls(load_image(fn, **merge(cls._open_args, kwargs)))\n",
    "\n",
    "    def show(self, ctx=None, **kwargs):\n",
    "        \"Show image using `merge(self._show_args, kwargs)`\"\n",
    "        return show_image(self, ctx=ctx, **merge(self._show_args, kwargs))\n",
    "\n",
    "    def __repr__(self): return f'{self.__class__.__name__} mode={self.mode} size={\"x\".join([str(d) for d in self.size])}'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#export\n",
    "class PILImage(PILBase): pass"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#export\n",
    "class PILImageBW(PILImage): _show_args,_open_args = {'cmap':'Greys'},{'mode': 'L'}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "im = PILImage.create(TEST_IMAGE)\n",
    "test_eq(type(im), PILImage)\n",
    "test_eq(im.mode, 'RGB')\n",
    "test_eq(str(im), 'PILImage mode=RGB size=1200x803')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<PIL.Image.Image image mode=RGB size=64x64 at 0x7F5FA4373950>"
      ]
     },
     "execution_count": null,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "im.resize((64,64))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 72x72 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "ax = im.show(figsize=(1,1))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "test_fig_exists(ax)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "timg = TensorImage(image2tensor(im))\n",
    "tpil = PILImage.create(timg)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<PIL.Image.Image image mode=RGB size=64x64 at 0x7F5FA4310210>"
      ]
     },
     "execution_count": null,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "tpil.resize((64,64))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#hide\n",
    "test_eq(np.array(im), np.array(tpil))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#export\n",
    "class PILMask(PILBase): _open_args,_show_args = {'mode':'L'},{'alpha':0.5, 'cmap':'tab20'}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "im = PILMask.create(TEST_IMAGE)\n",
    "test_eq(type(im), PILMask)\n",
    "test_eq(im.mode, 'L')\n",
    "test_eq(str(im), 'PILMask mode=L size=1200x803')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#export\n",
    "OpenMask = Transform(PILMask.create)\n",
    "OpenMask.loss_func = CrossEntropyLossFlat(axis=1)\n",
    "PILMask.create = OpenMask"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Images"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "mnist = untar_data(URLs.MNIST_TINY)\n",
    "fns = get_image_files(mnist)\n",
    "mnist_fn = TEST_IMAGE_BW"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAABwAAAAcCAAAAABXZoBIAAAA4klEQVR4nGNgGEjgu/Xf//gIrFLMiZ/+/v3793cpPxZJkWN/IeC9NUKQCUq/Wfab4fv9VwwMfP7YDM5r3MAQ/Pfv30MSWO2VYgj++/fvXwMMYxkYGBieMTAwMDAceIZVEgLOvsIhmYLVOgYGBgYGx29///5dz4Jdcs3fv3//uuHQ6fT379+/78ywSwo6vvj79+9UVhx6dXv//v1bjUVC8+zZs4pMDX//fk2GCSHcxmnAwLBlnQEDw6cbmDqNoNHy9wpcCBEIj/fhcAjEXKvNv//+/XtbB4d899+/TYb4DKA9AABLQV4KAJgjfgAAAABJRU5ErkJggg==\n",
      "text/plain": [
       "PILImageBW mode=L size=28x28"
      ]
     },
     "execution_count": null,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "timg = Transform(PILImageBW.create)\n",
    "mnist_img = timg(mnist_fn)\n",
    "test_eq(mnist_img.size, (28,28))\n",
    "assert isinstance(mnist_img, PILImageBW)\n",
    "mnist_img"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Segmentation masks"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#export\n",
    "class AddMaskCodes(Transform):\n",
    "    \"Add the code metadata to a `TensorMask`\"\n",
    "    def __init__(self, codes=None):\n",
    "        self.codes = codes\n",
    "        if codes is not None: self.vocab,self.c = codes,len(codes)\n",
    "\n",
    "    def decodes(self, o:TensorMask):\n",
    "        if self.codes is not None: o._meta = {'codes': self.codes}\n",
    "        return o"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "camvid = untar_data(URLs.CAMVID_TINY)\n",
    "fns = get_image_files(camvid/'images')\n",
    "cam_fn = fns[0]\n",
    "mask_fn = camvid/'labels'/f'{cam_fn.stem}_P{cam_fn.suffix}'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "cam_img = PILImage.create(cam_fn)\n",
    "test_eq(cam_img.size, (128,96))\n",
    "tmask = Transform(PILMask.create)\n",
    "mask = tmask(mask_fn)\n",
    "test_eq(type(mask), PILMask)\n",
    "test_eq(mask.size, (128,96))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 864x216 with 3 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "_,axs = plt.subplots(1,3, figsize=(12,3))\n",
    "cam_img.show(ctx=axs[0], title='image')\n",
    "mask.show(alpha=1, ctx=axs[1], vmin=1, vmax=30, title='mask')\n",
    "cam_img.show(ctx=axs[2], title='superimposed')\n",
    "mask.show(ctx=axs[2], vmin=1, vmax=30);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Points"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# export\n",
    "class TensorPoint(TensorBase):\n",
    "    \"Basic type for points in an image\"\n",
    "    _show_args = dict(s=10, marker='.', c='r')\n",
    "\n",
    "    @classmethod\n",
    "    def create(cls, t, img_size=None)->None:\n",
    "        \"Convert an array or a list of points `t` to a `Tensor`\"\n",
    "        return cls(tensor(t).view(-1, 2).float(), img_size=img_size)\n",
    "\n",
    "    def show(self, ctx=None, **kwargs):\n",
    "        if 'figsize' in kwargs: del kwargs['figsize']\n",
    "        x = self.view(-1,2)\n",
    "        ctx.scatter(x[:, 0], x[:, 1], **{**self._show_args, **kwargs})\n",
    "        return ctx"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#export\n",
    "TensorPointCreate = Transform(TensorPoint.create)\n",
    "TensorPointCreate.loss_func = MSELossFlat()\n",
    "TensorPoint.create = TensorPointCreate"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Points are expected to come as an array/tensor of shape `(n,2)` or as a list of lists with two elements. Unless you change the defaults in `PointScaler` (see later on), coordinates should go from 0 to width/height, with the first one being the column index (so from 0 to width) and the second one being the row index (so from 0 to height).\n",
    "\n",
    "> Note: This is different from the usual indexing convention for arrays in numpy or in PyTorch, but it's the way points are expected by matplotlib or the internal functions in PyTorch like `F.grid_sample`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "pnt_img = TensorImage(mnist_img.resize((28,35)))\n",
    "pnts = np.array([[0,0], [0,35], [28,0], [28,35], [9, 17]])\n",
    "tfm = Transform(TensorPoint.create)\n",
    "tpnts = tfm(pnts)\n",
    "test_eq(tpnts.shape, [5,2])\n",
    "test_eq(tpnts.dtype, torch.float32)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 72x72 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "ctx = pnt_img.show(figsize=(1,1), cmap='Greys')\n",
    "tpnts.show(ctx=ctx);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Bounding boxes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# export\n",
    "def get_annotations(fname, prefix=None):\n",
    "    \"Open a COCO style json in `fname` and returns the lists of filenames (with maybe `prefix`) and labelled bboxes.\"\n",
    "    annot_dict = json.load(open(fname))\n",
    "    id2images, id2bboxes, id2cats = {}, collections.defaultdict(list), collections.defaultdict(list)\n",
    "    classes = {o['id']:o['name'] for o in annot_dict['categories']}\n",
    "    for o in annot_dict['annotations']:\n",
    "        bb = o['bbox']\n",
    "        id2bboxes[o['image_id']].append([bb[0],bb[1], bb[0]+bb[2], bb[1]+bb[3]])\n",
    "        id2cats[o['image_id']].append(classes[o['category_id']])\n",
    "    id2images = {o['id']:ifnone(prefix, '') + o['file_name'] for o in annot_dict['images'] if o['id'] in id2bboxes}\n",
    "    ids = list(id2images.keys())\n",
    "    return [id2images[k] for k in ids], [(id2bboxes[k], id2cats[k]) for k in ids]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Test ```get_annotations``` on the coco_tiny dataset against both image filenames and bounding box labels. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "coco = untar_data(URLs.COCO_TINY)\n",
    "test_images, test_lbl_bbox = get_annotations(coco/'train.json')\n",
    "annotations = json.load(open(coco/'train.json'))\n",
    "categories, images, annots = map(lambda x:L(x),annotations.values())\n",
    "\n",
    "test_eq(test_images, images.attrgot('file_name'))\n",
    "\n",
    "def bbox_lbls(file_name):\n",
    "    img = images.filter(lambda img:img['file_name']==file_name)[0]\n",
    "    bbs = annots.filter(lambda a:a['image_id'] == img['id'])\n",
    "    i2o = {k['id']:k['name'] for k in categories}\n",
    "    lbls = [i2o[cat] for cat in bbs.attrgot('category_id')]\n",
    "    bboxes = [[bb[0],bb[1], bb[0]+bb[2], bb[1]+bb[3]] for bb in bbs.attrgot('bbox')]\n",
    "    return [bboxes, lbls]\n",
    "\n",
    "for idx in random.sample(range(len(images)),5): \n",
    "    test_eq(test_lbl_bbox[idx], bbox_lbls(test_images[idx]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# export\n",
    "from matplotlib import patches, patheffects"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# export\n",
    "def _draw_outline(o, lw):\n",
    "    o.set_path_effects([patheffects.Stroke(linewidth=lw, foreground='black'), patheffects.Normal()])\n",
    "\n",
    "def _draw_rect(ax, b, color='white', text=None, text_size=14, hw=True, rev=False):\n",
    "    lx,ly,w,h = b\n",
    "    if rev: lx,ly,w,h = ly,lx,h,w\n",
    "    if not hw: w,h = w-lx,h-ly\n",
    "    patch = ax.add_patch(patches.Rectangle((lx,ly), w, h, fill=False, edgecolor=color, lw=2))\n",
    "    _draw_outline(patch, 4)\n",
    "    if text is not None:\n",
    "        patch = ax.text(lx,ly, text, verticalalignment='top', color=color, fontsize=text_size, weight='bold')\n",
    "        _draw_outline(patch,1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# export\n",
    "class TensorBBox(TensorPoint):\n",
    "    \"Basic type for a tensor of bounding boxes in an image\"\n",
    "    @classmethod\n",
    "    def create(cls, x, img_size=None)->None: return cls(tensor(x).view(-1, 4).float(), img_size=img_size)\n",
    "\n",
    "    def show(self, ctx=None, **kwargs):\n",
    "        x = self.view(-1,4)\n",
    "        for b in x: _draw_rect(ctx, b, hw=False, **kwargs)\n",
    "        return ctx"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Bounding boxes are expected to come as tuple with an array/tensor of shape `(n,4)` or as a list of lists with four elements and a list of corresponding labels. Unless you change the defaults in `PointScaler` (see later on), coordinates for each bounding box should go from 0 to width/height, with the following convention: x1, y1, x2, y2 where (x1,y1) is your top-left corner and (x2,y2) is your bottom-right corner.\n",
    "\n",
    "> Note: We use the same convention as for points with x going from 0 to width and y going from 0 to height."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# export\n",
    "class LabeledBBox(L):\n",
    "    \"Basic type for a list of bounding boxes in an image\"\n",
    "    def show(self, ctx=None, **kwargs):\n",
    "        for b,l in zip(self.bbox, self.lbl):\n",
    "            if l != '#na#': ctx = retain_type(b, self.bbox).show(ctx=ctx, text=l)\n",
    "        return ctx\n",
    "\n",
    "    bbox,lbl = add_props(lambda i,self: self[i])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "coco = untar_data(URLs.COCO_TINY)\n",
    "images, lbl_bbox = get_annotations(coco/'train.json')\n",
    "idx=2\n",
    "coco_fn,bbox = coco/'train'/images[idx],lbl_bbox[idx]\n",
    "coco_img = timg(coco_fn)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 216x216 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "tbbox = LabeledBBox(TensorBBox(bbox[0]), bbox[1])\n",
    "ctx = coco_img.show(figsize=(3,3), cmap='Greys')\n",
    "tbbox.show(ctx=ctx);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Basic Transforms"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Unless specifically mentioned, all the following transforms can be used as single-item transforms (in one of the list in the `tfms` you pass to a `TfmdDS` or a `Datasource`) or tuple transforms (in the `tuple_tfms` you pass to a `TfmdDS` or a `Datasource`). The safest way that will work across applications is to always use them as `tuple_tfms`. For instance, if you have points or bounding boxes as targets and use `Resize` as a single-item transform, when you get to `PointScaler` (which is a tuple transform) you won't have the correct size of the image to properly scale your points."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# export\n",
    "PILImage  ._tensor_cls = TensorImage\n",
    "PILImageBW._tensor_cls = TensorImageBW\n",
    "PILMask   ._tensor_cls = TensorMask"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#export\n",
    "@ToTensor\n",
    "def encodes(self, o:PILBase): return o._tensor_cls(image2tensor(o))\n",
    "@ToTensor\n",
    "def encodes(self, o:PILMask): return o._tensor_cls(image2tensor(o)[0])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Any data augmentation transform that runs on PIL Images must be run before this transform."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "ToTensor:\n",
      "encodes: (PILMask,object) -> encodes\n",
      "(PILBase,object) -> encodes\n",
      "decodes: \n",
      "<class '__main__.PILImageBW'>\n",
      "<class 'fastai.torch_core.TensorImageBW'>\n"
     ]
    }
   ],
   "source": [
    "tfm = ToTensor()\n",
    "print(tfm)\n",
    "print(type(mnist_img))\n",
    "print(type(tfm(mnist_img)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "tfm = ToTensor()\n",
    "test_eq(tfm(mnist_img).shape, (1,28,28))\n",
    "test_eq(type(tfm(mnist_img)), TensorImageBW)\n",
    "test_eq(tfm(mask).shape, (96,128))\n",
    "test_eq(type(tfm(mask)), TensorMask)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's confirm we can pipeline this with `PILImage.create`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 72x72 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "pipe_img = Pipeline([PILImageBW.create, ToTensor()])\n",
    "img = pipe_img(mnist_fn)\n",
    "test_eq(type(img), TensorImageBW)\n",
    "pipe_img.show(img, figsize=(1,1));"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 216x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "def _cam_lbl(x): return mask_fn\n",
    "cam_tds = Datasets([cam_fn], [[PILImage.create, ToTensor()], [_cam_lbl, PILMask.create, ToTensor()]])\n",
    "show_at(cam_tds, 0);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To work with data augmentation, and in particular the `grid_sample` method, points need to be represented with coordinates going from -1 to 1 (-1 being top or left, 1 bottom or right), which will be done unless you pass `do_scale=False`. We also need to make sure they are following our convention of points being x,y coordinates, so pass along `y_first=True` if you have your data in an y,x format to add a flip.\n",
    "\n",
    "> Warning: This transform needs to run on the tuple level, before any transform that changes the image size."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#export\n",
    "def _scale_pnts(y, sz, do_scale=True, y_first=False):\n",
    "    if y_first: y = y.flip(1)\n",
    "    res = y * 2/tensor(sz).float() - 1 if do_scale else y\n",
    "    return TensorPoint(res, img_size=sz)\n",
    "\n",
    "def _unscale_pnts(y, sz): return TensorPoint((y+1) * tensor(sz).float()/2, img_size=sz)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#export\n",
    "class PointScaler(Transform):\n",
    "    \"Scale a tensor representing points\"\n",
    "    order = 1\n",
    "    def __init__(self, do_scale=True, y_first=False): self.do_scale,self.y_first = do_scale,y_first\n",
    "    def _grab_sz(self, x):\n",
    "        self.sz = [x.shape[-1], x.shape[-2]] if isinstance(x, Tensor) else x.size\n",
    "        return x\n",
    "\n",
    "    def _get_sz(self, x):\n",
    "        sz = x.get_meta('img_size')\n",
    "        assert sz is not None or self.sz is not None, \"Size could not be inferred, pass it in the init of your TensorPoint with `img_size=...`\"\n",
    "        return sz if self.sz is None else self.sz\n",
    "\n",
    "    def setups(self, dl):\n",
    "        its = dl.do_item(0)\n",
    "        for t in its:\n",
    "            if isinstance(t, TensorPoint): self.c = t.numel()\n",
    "\n",
    "    def encodes(self, x:(PILBase,TensorImageBase)): return self._grab_sz(x)\n",
    "    def decodes(self, x:(PILBase,TensorImageBase)): return self._grab_sz(x)\n",
    "\n",
    "    def encodes(self, x:TensorPoint): return _scale_pnts(x, self._get_sz(x), self.do_scale, self.y_first)\n",
    "    def decodes(self, x:TensorPoint): return _unscale_pnts(x.view(-1, 2), self._get_sz(x))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To work with data augmentation, and in particular the `grid_sample` method, points need to be represented with coordinates going from -1 to 1 (-1 being top or left, 1 bottom or right), which will be done unless you pass `do_scale=False`. We also need to make sure they are following our convention of points being x,y coordinates, so pass along `y_first=True` if you have your data in an y,x format to add a flip.\n",
    "\n",
    "> Note: This transform automatically grabs the sizes of the images it sees before a <code>TensorPoint</code> object and embeds it in them. For this to work, those images need to be before any points in the order of your final tuple. If you don't have such images, you need to embed the size of the corresponding image when creating a <code>TensorPoint</code> by passing it with `sz=...`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def _pnt_lbl(x): return TensorPoint.create(pnts)\n",
    "def _pnt_open(fn): return PILImage(PILImage.create(fn).resize((28,35)))\n",
    "pnt_tds = Datasets([mnist_fn], [_pnt_open, [_pnt_lbl]])\n",
    "pnt_tdl = TfmdDL(pnt_tds, bs=1, after_item=[PointScaler(), ToTensor()])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "test_eq(pnt_tdl.after_item.c, 10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#hide\n",
    "#Check the size was grabbed by PointScaler and added to y\n",
    "tfm = PointScaler()\n",
    "tfm.as_item=False\n",
    "x,y = tfm(pnt_tds[0])\n",
    "test_eq(tfm.sz, x.size)\n",
    "test_eq(y.get_meta('img_size'), x.size)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x,y = pnt_tdl.one_batch()\n",
    "#Scaling and flipping properly done\n",
    "#NB: we added a point earlier at (9,17); formula below scales to (-1,1) coords\n",
    "test_close(y[0], tensor([[-1., -1.], [-1.,  1.], [1.,  -1.], [1., 1.], [9/14-1, 17/17.5-1]]))\n",
    "a,b = pnt_tdl.decode_batch((x,y))[0]\n",
    "test_eq(b, tensor(pnts).float())\n",
    "#Check types\n",
    "test_eq(type(x), TensorImage)\n",
    "test_eq(type(y), TensorPoint)\n",
    "test_eq(type(a), TensorImage)\n",
    "test_eq(type(b), TensorPoint)\n",
    "test_eq(b.get_meta('img_size'), (28,35)) #Automatically picked the size of the input"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 144x144 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "pnt_tdl.show_batch(figsize=(2,2), cmap='Greys');"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#export\n",
    "class BBoxLabeler(Transform):\n",
    "    def setups(self, dl): self.vocab = dl.vocab\n",
    "\n",
    "    def decode (self, x, **kwargs):\n",
    "        self.bbox,self.lbls = None,None\n",
    "        return self._call('decodes', x, **kwargs)\n",
    "\n",
    "    def decodes(self, x:TensorMultiCategory):\n",
    "        self.lbls = [self.vocab[a] for a in x]\n",
    "        return x if self.bbox is None else LabeledBBox(self.bbox, self.lbls)\n",
    "\n",
    "    def decodes(self, x:TensorBBox):\n",
    "        self.bbox = x\n",
    "        return self.bbox if self.lbls is None else LabeledBBox(self.bbox, self.lbls)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#export\n",
    "#LabeledBBox can be sent in a tl with MultiCategorize (depending on the order of the tls) but it is already decoded.\n",
    "@MultiCategorize\n",
    "def decodes(self, x:LabeledBBox): return x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#export\n",
    "@PointScaler\n",
    "def encodes(self, x:TensorBBox):\n",
    "    pnts = self.encodes(cast(x.view(-1,2), TensorPoint))\n",
    "    return cast(pnts.view(-1, 4), TensorBBox)\n",
    "\n",
    "@PointScaler\n",
    "def decodes(self, x:TensorBBox):\n",
    "    pnts = self.decodes(cast(x.view(-1,2), TensorPoint))\n",
    "    return cast(pnts.view(-1, 4), TensorBBox)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def _coco_bb(x):  return TensorBBox.create(bbox[0])\n",
    "def _coco_lbl(x): return bbox[1]\n",
    "\n",
    "coco_tds = Datasets([coco_fn], [PILImage.create, [_coco_bb], [_coco_lbl, MultiCategorize(add_na=True)]], n_inp=1)\n",
    "coco_tdl = TfmdDL(coco_tds, bs=1, after_item=[BBoxLabeler(), PointScaler(), ToTensor()])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#hide\n",
    "#Check the size was grabbed by PointScaler and added to y\n",
    "tfm = PointScaler()\n",
    "tfm.as_item=False\n",
    "x,y,z = tfm(coco_tds[0])\n",
    "test_eq(tfm.sz, x.size)\n",
    "test_eq(y.get_meta('img_size'), x.size)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Categorize -- {'vocab': None, 'sort': True, 'add_na': True}:\n",
       "encodes: (object,object) -> encodes\n",
       "decodes: (object,object) -> decodes"
      ]
     },
     "execution_count": null,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Categorize(add_na=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(#3) [Pipeline: PILBase.create,Pipeline: _coco_bb,Pipeline: _coco_lbl -> MultiCategorize -- {'vocab': None, 'sort': True, 'add_na': True}]"
      ]
     },
     "execution_count": null,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "coco_tds.tfms"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(PILImage mode=RGB size=128x128,\n",
       " TensorBBox([[-0.9011, -0.4606,  0.1416,  0.6764],\n",
       "         [ 0.2000, -0.2405,  1.0000,  0.9102],\n",
       "         [ 0.4909, -0.9325,  0.9284, -0.5011]]),\n",
       " TensorMultiCategory([1, 1, 1]))"
      ]
     },
     "execution_count": null,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x,y,z"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x,y,z = coco_tdl.one_batch()\n",
    "test_close(y[0], -1+tensor(bbox[0])/64)\n",
    "test_eq(z[0], tensor([1,1,1]))\n",
    "a,b,c = coco_tdl.decode_batch((x,y,z))[0]\n",
    "test_close(b, tensor(bbox[0]).float())\n",
    "test_eq(c.bbox, b)\n",
    "test_eq(c.lbl, bbox[1])\n",
    "\n",
    "#Check types\n",
    "test_eq(type(x), TensorImage)\n",
    "test_eq(type(y), TensorBBox)\n",
    "test_eq(type(z), TensorMultiCategory)\n",
    "test_eq(type(a), TensorImage)\n",
    "test_eq(type(b), TensorBBox)\n",
    "test_eq(type(c), LabeledBBox)\n",
    "test_eq(y.get_meta('img_size'), (128,128))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 288x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "coco_tdl.show_batch();"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#hide\n",
    "#test other direction works too\n",
    "coco_tds = Datasets([coco_fn], [PILImage.create, [_coco_lbl, MultiCategorize(add_na=True)], [_coco_bb]])\n",
    "coco_tdl = TfmdDL(coco_tds, bs=1, after_item=[BBoxLabeler(), PointScaler(), ToTensor()])\n",
    "\n",
    "x,y,z = coco_tdl.one_batch()\n",
    "test_close(z[0], -1+tensor(bbox[0])/64)\n",
    "test_eq(y[0], tensor([1,1,1]))\n",
    "a,b,c = coco_tdl.decode_batch((x,y,z))[0]\n",
    "test_eq(b, bbox[1])\n",
    "test_close(c.bbox, tensor(bbox[0]).float())\n",
    "test_eq(c.lbl, b)\n",
    "\n",
    "#Check types\n",
    "test_eq(type(x), TensorImage)\n",
    "test_eq(type(y), TensorMultiCategory)\n",
    "test_eq(type(z), TensorBBox)\n",
    "test_eq(type(a), TensorImage)\n",
    "test_eq(type(b), MultiCategory)\n",
    "test_eq(type(c), LabeledBBox)\n",
    "test_eq(z.get_meta('img_size'), (128,128))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Export -"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Converted 00_torch_core.ipynb.\n",
      "Converted 01_layers.ipynb.\n",
      "Converted 01a_losses.ipynb.\n",
      "Converted 02_data.load.ipynb.\n",
      "Converted 03_data.core.ipynb.\n",
      "Converted 04_data.external.ipynb.\n",
      "Converted 05_data.transforms.ipynb.\n",
      "Converted 06_data.block.ipynb.\n",
      "Converted 07_vision.core.ipynb.\n",
      "Converted 08_vision.data.ipynb.\n",
      "Converted 09_vision.augment.ipynb.\n",
      "Converted 09b_vision.utils.ipynb.\n",
      "Converted 09c_vision.widgets.ipynb.\n",
      "Converted 10_tutorial.pets.ipynb.\n",
      "Converted 10b_tutorial.albumentations.ipynb.\n",
      "Converted 11_vision.models.xresnet.ipynb.\n",
      "Converted 12_optimizer.ipynb.\n",
      "Converted 13_callback.core.ipynb.\n",
      "Converted 13a_learner.ipynb.\n",
      "Converted 13b_metrics.ipynb.\n",
      "Converted 14_callback.schedule.ipynb.\n",
      "Converted 14a_callback.data.ipynb.\n",
      "Converted 15_callback.hook.ipynb.\n",
      "Converted 15a_vision.models.unet.ipynb.\n",
      "Converted 16_callback.progress.ipynb.\n",
      "Converted 17_callback.tracker.ipynb.\n",
      "Converted 18_callback.fp16.ipynb.\n",
      "Converted 18a_callback.training.ipynb.\n",
      "Converted 18b_callback.preds.ipynb.\n",
      "Converted 19_callback.mixup.ipynb.\n",
      "Converted 20_interpret.ipynb.\n",
      "Converted 20a_distributed.ipynb.\n",
      "Converted 21_vision.learner.ipynb.\n",
      "Converted 22_tutorial.imagenette.ipynb.\n",
      "Converted 23_tutorial.vision.ipynb.\n",
      "Converted 24_tutorial.siamese.ipynb.\n",
      "Converted 24_vision.gan.ipynb.\n",
      "Converted 30_text.core.ipynb.\n",
      "Converted 31_text.data.ipynb.\n",
      "Converted 32_text.models.awdlstm.ipynb.\n",
      "Converted 33_text.models.core.ipynb.\n",
      "Converted 34_callback.rnn.ipynb.\n",
      "Converted 35_tutorial.wikitext.ipynb.\n",
      "Converted 36_text.models.qrnn.ipynb.\n",
      "Converted 37_text.learner.ipynb.\n",
      "Converted 38_tutorial.text.ipynb.\n",
      "Converted 39_tutorial.transformers.ipynb.\n",
      "Converted 40_tabular.core.ipynb.\n",
      "Converted 41_tabular.data.ipynb.\n",
      "Converted 42_tabular.model.ipynb.\n",
      "Converted 43_tabular.learner.ipynb.\n",
      "Converted 44_tutorial.tabular.ipynb.\n",
      "Converted 45_collab.ipynb.\n",
      "Converted 46_tutorial.collab.ipynb.\n",
      "Converted 50_tutorial.datablock.ipynb.\n",
      "Converted 60_medical.imaging.ipynb.\n",
      "Converted 61_tutorial.medical_imaging.ipynb.\n",
      "Converted 65_medical.text.ipynb.\n",
      "Converted 70_callback.wandb.ipynb.\n",
      "Converted 71_callback.tensorboard.ipynb.\n",
      "Converted 72_callback.neptune.ipynb.\n",
      "Converted 73_callback.captum.ipynb.\n",
      "Converted 74_callback.cutmix.ipynb.\n",
      "Converted 97_test_utils.ipynb.\n",
      "Converted 99_pytorch_doc.ipynb.\n",
      "Converted dev-setup.ipynb.\n",
      "Converted index.ipynb.\n",
      "Converted quick_start.ipynb.\n",
      "Converted tutorial.ipynb.\n"
     ]
    }
   ],
   "source": [
    "#hide\n",
    "from nbdev.export import notebook2script\n",
    "notebook2script()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "jupytext": {
   "split_at_heading": true
  },
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}
